Automation

Lite includes a local automation runtime for executing playbook-shaped work with graph validation, run state, and pause/resume behavior.

Automation in Lite

The Lite automation runtime is built around local playbook execution. It lets you define a graph, validate it, create an automation, run it, inspect run state, and resume approval pauses through the public SDK.

Local playbook runtimeGraph validationRun lifecycleApproval pauses

What automation means in Aionis

Automation in Aionis is continuity-aware execution reuse.

Automation takes a reusable playbook or task graph and runs it through a local runtime that already understands replay, pause, approval, and artifact checks.

Public automation methods

SDK method	Route	Purpose
automations.validate(...)	POST /v1/automations/validate	Validate a graph against the Lite automation runtime
automations.graphValidate(...)	POST /v1/automations/graph/validate	Alternate validation entrypoint for graph validation
automations.create(...)	POST /v1/automations/create	Persist an automation definition
automations.get(...)	POST /v1/automations/get	Fetch one automation definition
automations.list(...)	POST /v1/automations/list	List automation definitions in Lite
automations.run(...)	POST /v1/automations/run	Start an automation run
automations.runs.get(...)	POST /v1/automations/runs/get	Inspect one run
automations.runs.list(...)	POST /v1/automations/runs/list	List local runs
automations.runs.cancel(...)	POST /v1/automations/runs/cancel	Cancel a run
automations.runs.resume(...)	POST /v1/automations/runs/resume	Resume a paused run

Supported Lite node kinds

The current Lite runtime supports these node kinds:

Node kind	What it does
playbook	Execute a replay playbook step
approval	Pause for a human or host-side approval gate
condition	Evaluate a boolean branch condition
artifact_gate	Require expected artifacts before continuing

This is enough to express useful local workflows through the public Lite path.

Minimal validation and create example

const graph = {
  nodes: [
    {
      node_id: "step_a",
      kind: "playbook",
      playbook_id: "pb_sync",
      version: 1,
      inputs: {},
    },
    {
      node_id: "gate_b",
      kind: "approval",
      approval_key: "local_gate",
      inputs: {
        source: "$nodes.step_a.summary.replay_readiness",
      },
    },
  ],
  edges: [{ from: "step_a", to: "gate_b", type: "on_success" }],
};

await aionis.automations.validate({
  tenant_id: "default",
  scope: "local-automation",
  graph,
});

await aionis.automations.create({
  tenant_id: "default",
  scope: "local-automation",
  actor: "docs-example",
  automation_id: "approval-flow",
  name: "Approval Flow",
  status: "draft",
  graph,
});

Minimal run example

const run = await aionis.automations.run({
  tenant_id: "default",
  scope: "local-automation",
  actor: "docs-example",
  automation_id: "approval-flow",
  options: {
    execution_mode: "default",
    record_run: true,
    stop_on_failure: true,
  },
});

Then inspect or resume the run:

await aionis.automations.runs.get({
  tenant_id: "default",
  scope: "local-automation",
  run_id: "run-id-from-start",
  include_nodes: true,
});

await aionis.automations.runs.resume({
  tenant_id: "default",
  scope: "local-automation",
  actor: "docs-example",
  run_id: "run-id-from-start",
  reason: "approval granted",
});

How automation relates to replay

Automation sits on top of the same continuity substrate as replay.

The practical relationship is:

1. replay records a successful run
2. replay compiles that run into a playbook
3. automation executes or coordinates that playbook in a local graph

That is why automation belongs in the runtime story rather than living as a separate side feature.

Automation in Lite today

Three things matter in Lite:

1. the automation runtime is local and explicit
2. approval pauses are supported
3. replay and automation share the same playbook model

Related docs

1. Replay and Playbooks
2. Lite Runtime
3. SDK Quickstart
4. Review Runtime