OpenAdapt Execute

Verified execution for the systems your product cannot integrate with.

Your product already knows the transaction. OpenAdapt completes it through the customer's browser, desktop, RDP, or Citrix session, then returns a verified receipt or a typed exception.

Qualify one transaction Discuss an OEM integration

OpenAdapt Execute is a private partner API and an OEM integration. We provision it with a qualified workflow and a commercial agreement.

The execution boundary

Keep business logic in your product. Put the last mile under a governed contract.

Vertical software, service providers, and operations teams often prepare the right structured data but cannot write it into each customer system. OpenAdapt carries the authorized transaction across that final boundary without turning your product into a general-purpose computer agent.

Your product: Chooses the transaction and supplies authorized, structured input.
Customer-controlled runner: Observes and acts inside the approved browser, desktop, remote session, or private network boundary.
OpenAdapt: Binds the workflow, authorization, identity, effect proof, evidence, and exception path.

Real RDP execution

See the external remote-session path.

This synthetic healthcare task crosses a real RDP client and server. OpenAdapt records the remote pixels, compiles the demonstration, verifies the intended record before the write, and checks the saved result outside the remote screen.

Reference qualification with synthetic data. The video uses paced presentation timing and exact retained RDP frames. A customer application and environment receive their own qualification.

3 / 3

Healthy RDP runs confirmed the intended identity and saved effect.

3 / 3

Changed-screen trials halted before a write.

Model calls and silent incorrect successes in the accepted batch.

Inspect the qualification evidence →Read the RDP architecture →

From request to receipt

Qualify one transaction

We bind the intended inputs, identity checks, effect proof, target environment, and exception path to one workflow version.

Send an authorized request

Your product sends a structured transaction to the private partner API. OpenAdapt dispatches it to the approved customer-controlled runner.

Receive a durable result

The execution returns a verified receipt when the required proof passes, or a typed exception when an authorized person or reconciliation is needed.

POST /v1/executions
→ 202 { schema_version: "openadapt.execute-accepted/v1",
        execution_id, state: "queued" }

webhook → { schema_version: "openadapt.execute-webhook/v1",
            event_type: "execution.terminal", receipt: { outcome: "verified" } }

Execution is asynchronous. A run can wait for an authorized decision, survive a restart, or require reconciliation without losing its transaction identity.

Clear outcomes

A receipt names what the runner proved and what needs attention.

verified

The runner completed the authorized work and proved the configured business effect.

reconciliation_required

The action may have reached the target, but the proof is incomplete. OpenAdapt does not repeat a consequential write blindly.

halted_before_effect

The runner refused before a business effect when identity, target, authorization, or policy evidence did not match.

rejected_policy

The authorization or policy contract rejected the request before execution could proceed.

failed_platform

The execution platform failed before any possible business effect.

rolled_back_verified

A configured compensating action completed and OpenAdapt independently verified its business effect.

Start with one deployment

Bring one transaction, one target environment, and one measurable business effect.

We qualify the first workflow with your team. That creates the reusable execution contract, customer-runner plan, mobile operator decision path, and evidence needed to scale it through your product.

Qualify one transaction Talk to partnerships