OpenAdapt: your agent decides, OpenAdapt enters it and checks it saved

OpenAdapt Agent

This repository has moved to the OpenAdapt monorepo (packages/agent). It is archived and read-only; open issues and PRs there. The PyPI package name openadapt-agent is unchanged.

Your AI agent decides what to enter. OpenAdapt enters it in the app and checks that it saved.

Use it if your agent reads referrals, intake forms, or authorizations and works out what belongs in the record, but a person still types the result into an app with no usable API. Examples are an electronic medical record (EMR) and a payer portal. This package is the tool your agent calls to do that typing.

• A person or your agent shows OpenAdapt the task in the real app. OpenAdapt replays those steps, and by default a run makes no AI model calls.
• Before it types, OpenAdapt checks that the right record is open. After it saves, it reads the record back.
• Your agent gets one of four outcomes: done and checked, stopped before saving, check the record, or didn't run. When OpenAdapt can't confirm a save, it says so, and a person checks the record.
• It runs on your customer's computer, one that can already open the app. Your agent, or a small program acting for it, has to run on that computer too, since it starts OpenAdapt and talks to it directly. If your agent runs in your own cloud, ask us about a hosted route.

Pick one task your agent hands to staff today and talk to us about connecting it. Engineers can try the sandbox first.

Give your agent a program, not a mouse

Your agent doesn't send screenshots to a model and click. It calls a taught workflow as one typed tool, OpenAdapt runs the same steps every time, and by default your agent gets back an outcome and counts, not screens or recorded values.

openadapt-agent serve --mode production --bundles <bundle or directory of bundles>

openadapt-agent emit-skill --out ~/.claude/skills

Try it in three steps runs a sandbox with no account. Serve your own workflows and Write an Agent Skill cover both commands.

What changes for your customer's team

For scale, two hospital time studies put keying one faxed referral into an electronic record at about 10 to 12 minutes (UCSF, JAMIA Open 2020; Calderdale and Huddersfield NHS Foundation Trust, HFMA 2024). We don't publish a time-saved number until a deployment measures one.

Who builds what

flowchart LR

A["Your agent reads the document and picks the values"] B["OpenAdapt enters them in the app on your customer's computer and reads the record back"] C["Your agent acts on the outcome"] D["A person at that computer decides or checks the record"] A -->|"workflow, inputs, request_id"| B B -->|"one outcome per request"| C B -.->|"needs_review or not_sure_if_saved"| D

Your customer provides the computer and a person for runs that stop. A person or an agent shows the task, in web apps, native Windows apps, and over Citrix or remote desktop. A person accepts the result before it runs. See Record a first workflow, or talk to us about setting it up.

Try it in three steps

The sandbox is a practice server that needs no account. It has one workflow, add_triage_note, which adds a note to the first referral in MockMed, a test clinic app with made-up patients.

You need Claude Code (signed in) and uv. To use a different client or your own code, see Connect your own agent.

1. Add the sandbox server. Claude Code saves it for the current folder only.

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

1. In the same folder, start Claude Code with claude. Claude Code starts the server.

1. Ask: "Use OpenAdapt to add the triage note 'Synthetic: recheck blood pressure in 2 weeks' with request id demo-0001."

Your agent should call list_workflows, then run_workflow with these arguments:

{"workflow": "add_triage_note", "inputs": {"note": "Synthetic: recheck blood pressure in 2 weeks"}, "request_id": "demo-0001"}

The result looks like this (some fields left out):

{

"outcome": "done", "label": "Done and checked", "safe_to_retry": false, "what_happened": "Simulated sandbox result (no app was opened): Saved the change and read the record back to confirm it.", "next_step": "none", "proof": "simulated", "run_id": "run-31ecb9d66db84f1aba8cb5f6", "model_calls": 0 }

This install simulates each run without opening MockMed, and every result says so. To watch the real engine do the work, see Drive MockMed with the real engine.

openadapt-agent installs from PyPI and requires openadapt-flow 2.1.0 or later, which is on PyPI and installs with it. To try unreleased changes, use --from git+https://github.com/OpenAdaptAI/openadapt-agent in place of the package name.

See every outcome

Ask for each case by adding sandbox_case to the inputs, with a new request_id each time. For example: "Now try the false_saved_banner case with request id demo-0002."

The sandbox remembers each request_id across sessions. Sending a used request_id with the same inputs returns the earlier result. Sending it with different inputs, such as a new sandbox_case, returns did_not_run with the reason request_id_conflict. To start over, delete ~/.openadapt/agent-sandbox, or set OPENADAPT_AGENT_SANDBOX_DIR to an empty folder.

Drive MockMed with the real engine

The tutorial extra makes openadapt-flow (Flow), the engine behind OpenAdapt, drive MockMed in a hidden browser. Replace the sandbox server with this one:

claude mcp remove openadapt

claude mcp add openadapt -- uvx --python 3.12 --from 'openadapt-agent[tutorial]' openadapt-agent serve

When the server starts, Flow records the workflow once and, if needed, downloads a browser (about 300 MB). The first request waits for that. In our test on a Mac, the first request took about 80 seconds. The call returned running after 60 seconds, and the agent called get_run for the result. If setup takes more than 15 minutes, the request ends did_not_run. With Flow, a done result has proof: "local" instead of "simulated".

The simulated sandbox suggests the same command in its list_workflows result.

What your agent gets back

outcome is one of four final values. While a run is still going, it's running.

Branch on outcome and safe_to_retry. next_step names the next move as a fixed code, so your code doesn't have to parse next_action: none, call_get_run, wait_for_person, check_record, fix_inputs, fix_setup, or retry.

Resend a request

request_id is your own id for the request, such as a referral id. Don't put patient details in it. A request is one request_id with one workflow and one set of inputs.

• Resending the same request never enters the values twice. It returns the latest result, marked replayed: true.
• If that result was did_not_run with safe_to_retry: true, resending starts a new attempt, up to 5 attempts per request_id.
• After invalid_input, you can fix the inputs and resend with the same request_id. After any other retryable result, send the same inputs.
• A different workflow or different inputs under a used request_id return did_not_run with request_id_conflict. Nothing new runs, and the earlier request may have saved. Call get_run with the result's first_run_id to see what happened to it.
• No tool clears not_sure_if_saved. If the person who checks finds the work still needs doing, send it as a new request with a new request_id.

The check that stops a second entry covers one runs folder. See --runs-dir under Set server options.

Read the other fields

• label: a short status you can display, such as "Done and checked".
• reason: a code from a fixed list that names the cause, such as invalid_input or request_id_conflict. Every code is in REASONS in contract.py, and docs/DESIGN.md explains how each one is chosen.
• `what_happen