A program from a demonstration

Record a GUI workflow once and replay it without calling an LLM every run

OpenAdapt compiles a demonstration into a program. The program reports VERIFIED only if an independent check agrees. You record the GUI workflow once. The default healthy replay follows that program and makes no generative-model API calls.

pip install openadapt
openadapt quickstart

Don't use this when a supported API covers the job. Use the API. Don't use it for a novel task that should be re-planned each run; that's a computer-use agent. A halt looks like this: two look-alike records share a name, OCR can't tell their numbers apart, and the program stops before it writes. See the wrong-patient defense

Run it locally Read the technical paper

How it works

Demonstrate, compile, check the effect, then VERIFIED or halt

You or the AI you already talk to can demonstrate. A person still has to admit the program. After that, the agent calls it and healthy runs make no model calls.

1
Demonstrate
Record one bounded workflow in its real application. You can show it, or the AI you already talk to can. A person still has to admit the program.
2
Compile
The recording becomes a program the agent can invoke. Review the steps, identities, expected results, and environment before you reuse a version.
3
Check the record
Before it says it worked, a separate read proves whether the change landed. That check may use an API, a database, a file, or a second session.
4
VERIFIED or halt
The run reports VERIFIED only when that check passes. If it can't prove the effect, it stops.

From demonstration to program

Inspect the program, the live run, and the evidence behind each decision.

See what a demonstration compiled into. A recording under-specifies intent. The compiler turns it into a program you can read before it runs: each step, the resolution ladder, where an identity gate is armed, which writes carry an effect check, and every point the run can halt.

Select a step to see its resolution evidence, identity gate, action contract, and result check. Then switch to the halt scenario. The same program stops before an unsafe action and keeps the exact comparison for review.

Program State ConsoleRepresentative synthetic program

v38d9c…42afpublic synthetic

Program artifact

Recorded evidence
Compiled program v3
Repair candidate v4
Review and trials
Active v4

One live run

1Current observation
2Resolve target
3Identity gate
4Act once
5Screen check
6Effect check
RUNNING

01 / 09

ObserveInput contract acceptedevent 01

Process Contract v1

Build the whole procedure, including the steps a person must own.

An OpenAdapt App is a sealed Process Contract. One governed process can include GUI work, exact code, and attended checkpoints. Each child keeps its own authority and evidence.

GUI workflowAdmitted Flow
Run an exact bundle with a live qualification admission. The child must return VERIFIED before the process can finish.
Exact computationSealed code
Run the admitted source archive and runtime. A separate verifier confirms each declared output digest before a downstream child can read it.
Attended workSigned human checkpoint
Pause for a closed review, decision, or action. Resume only from a signed receipt bound to this process and run. A downstream check still proves the effect of an action.

Declared input
Content-addressed artifact graph
Append-only run ledger
Signed terminal receipt

Portable by contract. Use a coding agent, chat model, local model, or person to author the package. The runner checks the same JSON contracts, digests, admissions, and receipts. It doesn't store a chat or assistant ID, and the authoring model isn't a runtime dependency.

Read Process Contract v1

Render a local program view

openadapt-flow visualize my-bundle --format html -o graph.html

Compile a governed worklist

openadapt-flow for-each my-bundle --records worklist.csv --out queue-bundle

See the reference catalog Read the compiler guide

Qualification · Human judgment

Capture the policy behind the action.

During qualification, your team can show how an institutional exception should be handled. OpenAdapt records the reviewed choice and the authority behind it. One answer never becomes policy by itself.

Rule candidate for review

Test the proposed rule against representative and fault cases before approval.

Permanent human decision node

Keep the choice with an authorized role whenever policy or discretion requires it.

More examples required

Collect contrasting cases when the available evidence does not justify a stable rule.

Try judgment capture

Mobile qualification screen that retains an insurance exception as an authorized human decision node — Canonical synthetic capture from the interactive qualification authoring demo.

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, so 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.

Where it runs

What each surface uses, and what it supports today

OpenAdapt keeps the workflow and its safety checks separate from the controls used in each application, so one surface can use structural evidence and another can use pixels without changing the workflow contract.

Browser
Uses DOM, accessibility, visual, and interaction evidence to run browser workflows.
Supports the complete record, compile, replay, and verify loop.
Native desktop
Operates Windows, macOS, and Linux applications through native accessibility plus retained visual evidence.
Uses the same workflow contract through customer-controlled qualification.
Remote applications
Operates RDP, Citrix Workspace, and VDI through pixels, keyboard, and mouse, with the same identity and result checks. The result check reads whatever channel the target system exposes, so a pixel-only surface still verifies out of band.
Uses the same workflow contract through customer-controlled qualification.

Each surface carries its own measured acceptance evidence in the qualification evidence

Choose the execution boundary

Managed execution

Use the OpenAdapt control plane and managed runners for approved browser and non-sensitive workloads.

Need a hosted runner? Talk to us.

Customer-controlled deployment

Run sensitive data, native applications, RDP, Citrix, private networks, and restricted-egress workflows inside your boundary. External black-box remote execution does not require software inside the managed session.

Review the security boundary

Remote execution modes

Two ways into managed Citrix, RDP, and VDI estates

Where policy permits software inside the managed session, the runner executes in-session. Where it does not, the external lane drives the local remote-desktop client window from outside, so nothing is installed in the remote environment. Both modes keep the same identity, policy, verification, and halt contracts.

In-session

The runner is installed inside the managed session, when your policy permits it.

Managed session (Citrix / RDP / VDI)

OpenAdapt runner

Runs beside the application with native accessibility and visual evidence.

native control and evidence

Target application

The system-of-record UI inside the session.

Requires software inside the session image, so it fits estates where you control the image or policy allows an installed agent.

External black-box

The runner drives the local Citrix or RDP client window. Zero install inside the remote session.

Your workstation

OpenAdapt runner (outside the session)

Operates through pixels, keyboard, and mouse with a two-phase lease: re-resolve on a fresh frame, refuse if anything changed before delivery.

pixels, keyboard, mouse

Local Citrix / RDP client window

The vendor client you already run.

the vendor's own remote protocol

Managed session (remote)

Untouched: no agent, driver, or install inside the session.

Fits locked-down estates where nothing may be installed in the managed environment.

Status, stated plainly: the external lane is qualified today against a deterministic no-DOM stand-in for the Citrix Workspace window contract and a real FreeRDP round trip for RDP. A real ICA/HDX environment is qualified per customer before consequential use. Per surface results are published in the qualification evidence, and machine-readable status in status.json.

Real application footage

Watch the same governed loop in real applications

Choose an application, compare the recorded demonstration with its compiled replay, and open the evidence behind the result.

OpenAdaptObservingStep 1 of 33Observing the application

0:00 / 0:00Evidence

Guided view synchronized to the exact retained runtime timeline; raw footage remains unchanged.

1
DemonstrateCapture the task and its evidence.
2
ExecuteReplay the compiled workflow locally.
3
Verify or haltProve the effect, or stop for review.