Pilot automation

Stop clicking. Start piloting.

Record provider-dashboard workflows, replay them as deterministic Playwright playbooks, and use AI only where it helps: authoring, selector healing, bounded decisions, and review summaries.

Get started View playbooks

Cloudflare

API gap

Dashboard-only toggles, one-off confirmations, and account context checks.

cloudflare.dns.add-a-record

GoDaddy

API gap

Frequent layout drift and DNS controls that are not consistently covered by APIs.

godaddy.dns.add-record

DigitalOcean

API gap

Personal access tokens are generated interactively and revealed once.

digitalocean.token.create

Three operating modes.

Interactive demo
Pilot run console
digitalocean.token.create
Interactive mode

Operators approve each breakpoint with the resolved selector, masked values, and a highlighted screenshot.

recording
00:58
video + trace + screenshots
Open provider dashboard
navigate · goto-dns
done
2
Resolve Add record button
click · open-add-record
approve
3
Fill record fields
fill · fill-record
pending
4
Save and capture result
capture · save
pending
event stream
› step.awaiting_approval open-add-record
› operator sees screenshot highlight + selector
› approval required before destructive or credential steps
› edited selector can be persisted as a new playbook version
Breakpoint approval
selector: role=button[name=/generate new token/i]
ApproveEdit

Playbooks are the automation contract.

AI can draft or heal a flow, but the saved artifact is declarative, versioned, reviewable `.cuitty` playbook data that Playwright executes deterministically. Existing YAML playbooks remain importable during migration. 

playbook:
  id: cloudflare.dns.add-a-record
  version: 3
  target: cloudflare
  title: Add an A record to a DNS zone
  inputs:
    - name: zone
      type: string
      required: true
    - name: record_name
      type: string
      required: true
    - name: ip_address
      type: ipv4
      required: true
    - name: proxied
      type: boolean
      default: true
  preconditions:
    - session_authenticated: cloudflare
  steps:
    - id: open-add-record
      action: click
      selector:
        primary: "button:has-text('Add record')"
        fallbacks:
          - "[data-testid='add-dns-record']"
          - "role=button[name=/add record/i]"
      ai_fallback: true
      intent: Open the create-record form.
    - id: save
      action: click
      selector: "button:has-text('Save')"
      assert:
        - text_present: Record added
    - id: capture-id
      action: capture
      capture_as: record_id
      from:
        network_response:
          url_pattern: "/dns_records"
          method: POST
          json_path: "$.result.id"
AI authors, Playwright executes

Observe. Propose. Validate. Persist.

When a selector misses, Pilot packages visible text, accessibility tree, screenshot, step intent, and recent trace context for the AI bridge. A successful proposal is validated against the page before it can become a new fallback selector.

01
observe
02
propose
03
validate
04
persist

Record. Refine. Trust.

Record

Capture a human click-through as structured events, screenshots, DOM snapshots, and network context.

Refine

Let AI rank selectors, parameterize inputs, add assertions, and propose a clean playbook diff.

Trust

Every replay records again and emits run metadata, artifacts, and audit events.

Pilot → Video

Every run becomes a video.

Watch how each Pilot step generates a Video frame. The bridge auto-generates a `.cuitty` video block from the run artifacts — screenshots, recordings, and step metadata.

Pilot Run

executing
Navigate to DNS management page
goto-dns · 1200ms
2
Click 'Add Record' button
add-record · 800ms
3
Fill A record: api.example.com → 1.2.3.4
fill-record · 2000ms
4
Click Save and verify success banner
save · 600ms
Network: 4 requestsConsole: 0 errorsDOM: 12 mutations

Video Pipeline

composing
Frame 1
frames/001-dns-page.png
screenshot
Frame 2
frames/002-add-record.png
screenshot
Frame 3
recordings/003-fill.webm
recording
Frame 4
frames/004-saved.png
screenshot
Render pipeline
Playwright + FFmpeg.mp4 + .webm4600ms total
Rendered video
.mp4
dash.cloudflare.com
Cloudflare Dashboardacme-prod
DNS
SSL
Firewall
Workers
DNS Records
Awww.example.com1.2.3.4
MXmail.example.com10 mx1.example.com
SCREENSHOT
0:00
Step 1/4Navigate to DNS management page0:00 / 0:04
Review mode

Failed runs become fixable evidence.

Operators mark the exact failed step range or video span. Pilot builds a redacted Failure Summary with selectors tried, screenshots, console errors, network window, and the step intent, then asks the AI bridge for a concrete playbook diff.

Security model.

Every run records video, trace, network, console, and per-step screenshots.
Secrets captured by playbooks are redacted before artifacts persist.
SpiceDB separates run, destructive-run, provider, playbook, and secret viewing permissions.
Integration map

One workflow, eight products.

Pilot doesn't stand alone. Hover a product to see what data flows between it and Pilot.

VideoPilot →

Every Pilot run is recorded via the Video render pipeline.

  • Pilot sends: per-step screenshots, screen recordings, DOM snapshots
  • Video returns: composed .mp4/.webm with step overlays and failure highlights
ObservePilot →

Run, step, secret, and review events flow through the ModuleEventBus.

  • Pilot sends: audit events, trace spans, errors
  • Observe stores: in audit, traces, and errors modules
CodePilot ↔

Playbooks are versioned YAML. AI-healed selectors become PRs.

  • Pilot reads: playbook YAML from Code repositories
  • Pilot writes: healed playbook diffs as PRs
  • Code runs: Pilot playbooks in CI via Airflow
Tests→ Pilot

Import playbooks as test cases. The test runner drives Pilot in headless mode.

  • Tests imports: Pilot playbooks as type=pilot test cases
  • Tests drives: Pilot in headless mode with captured outputs
  • Tests asserts: on step completion status and captured values
ToolbarPilot →

Active run status and badges appear in the Cuitty Toolbar.

  • Pilot sends: run status, step progress
  • Toolbar shows: real-time Pilot badge with run count
Auth→ Pilot

OIDC tokens scoped per provider for secure browser sessions.

  • Auth provides: project-scoped OIDC tokens
  • Pilot uses: tokens for browser sessions
  • SpiceDB enforces: run and playbook permissions

Start automating your provider dashboards.

Pilot keeps dashboard automation auditable, replayable, and self-hosted: deterministic playbooks first, AI assistance only when it creates a better path.

See all Cuitty products →