Verified automation from demonstration

Compile once, govern every repair

Record a bounded, repeated task once. OpenAdapt compiles the trace into a deterministic local program, replays it with zero per-run model cost, and resolves, repairs, or halts under interface drift. Here is what each step produces and where the loop deliberately stops.

Start your first workflow Read the technical paper

How it works

One demonstrated task becomes one approved program

The recording starts the work. Qualification defines what the program may do and what evidence counts as success.

1
Show the task
Record one bounded workflow in its real application. OpenAdapt retains the actions and the evidence around each step.
2
Qualify the program
Review the compiled steps, identities, expected results, failure cases, and target environment before you approve a version.
3
Run and verify
Replay the approved program. OpenAdapt checks the declared result, stops on uncertainty, and keeps each repair behind the same review gates.

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

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 approved web 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.

See Cloud pricing

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.