Skip to main content
/

Stop your web agents from breaking on layout shifts, SPAs, and bloated DOMs.

Web agents look great in local demos, but break on live sites: they click empty space when pages shift, overlap badges on complex apps, and freeze silently mid-run. Aliax is a 10-line drop-in that locks onto live elements, keeps visual badges clean, and provides instant visual crash replays. Works alongside Browser-Use, Stagehand, or any custom agent.

  • Zero misclicksLocks onto the real button, even if an ad or popup moves it mid-click
  • 10-line drop-inPlugs into Browser-Use, Stagehand, or LangChain without changing your planner
  • 90% fewer tokensShrinks messy web pages into a clean 1.5k view your model loves
  • Visual crash replaySee the exact screenshot and thoughts the second an agent gets stuck
  • drop-in SDK · Browser-Use · Stagehand · LangChain · custom agents

    ~/agent · zero-config sandbox
    $
    // 1. Zero signup — boots a keyless local sandbox (500 free parses)
    import { Aliax, SYSTEM_INSTRUCTIONS } from "aliax";
    const aliax = new Aliax();
    
    // 2. CLS-immune perception: 1.5k visual map + Set-of-Mark screenshot
    const ctx = await aliax.parseUi(page);
    
    // 3. Your VLM picks an element_id — Aliax resolves & executes live (0 ghost clicks)
    const decision = await askLLM(ctx);   // {action: "CLICK", element_id: "el_41"}
    await aliax.execute(page, decision);

    No API key required. Automatically caches a free sandbox (500 parses) in ~/.aliax/credentials on first run.

    the missing reliability runtime for Browser-Use, Stagehand & custom VLM agents

    • immune to layout shifts
    • 0misclicks
    • 90%smaller prompts
    • <90msp99 parseUi*
    • PII redaction · bundled mapper
    • append-only ledger · per-call receipt
    • open-source SDK· MIT
    • python · node parity

    why web agents break in production

    The difference between a local demo and production uptime.

    Frameworks like Browser-Use and Stagehand handle planning. But when real websites shift layouts, pop up banners, or stack buttons, agents fail. Aliax makes sure every action actually lands.

    Without Aliax

    Fragile Execution

    With Aliax (drop-in SDK)

    Rock-Solid Execution

    • Clicks empty space when ads, popups, or banners shift the page
    • Badges overlap on dense buttons, hiding the text your model needs
    • 50k–100k token dumps that slow down calls and spike API bills
    • Agent freezes silently at step 8 with zero error logs or clues
    • Can't find buttons hidden inside shadow DOMs, SVGs, or iframes
    • Locks onto the live button — never misclicks, even after layout shifts
    • Clean, separated badges that never cover each other or page text
    • Compact 1.5k token view — fast responses and tiny API costs
    • Instant visual replay showing the exact screen and thoughts where it stalled
    • Finds every clickable button, including shadow DOMs and checkout iframes

    Wires into your existing stack in < 10 lines

    Browser-UseStagehandLangChaincustom agents

    See what breaks your agents in production. Measure it on your URL.

    Paste any public URL. A headless Chromium on Cloudflare runs the published Aliax SDK, stamps stable CLS-immune element IDs, and streams exact token counts vs raw HTML and aria-snapshot baselines. Every number measured server-side — nothing mocked, nothing cached.

    recently measured · click any to run live

    your URL is never storedreproducible via curlworks with any public URL

    See token breakdown, element overlay, and scale calculator on the full benchmark page

    why developers add Aliax to their stack

    No misclicks. 90% smaller prompts. Instant visual crash replays.

    0 ghost clicks100k → 1.5k tokens$0.0015 / parse<90ms p99
    Pillar 01 · The Steady Hand

    Clicks the right button every time

    The pain

    Traditional visual agents click blind X,Y coordinates. If an ad loads, a banner appears, or a page re-renders, they click empty space and fail.

    The Aliax fix

    Aliax locks onto the live button directly on the page at the exact moment of execution. Popups, banners, layout shifts, and mobile viewports can't throw it off.

    0 ghost clicks
    across 1.2M live runs
    Pillar 02 · The Compactor

    90% smaller prompts on modern web apps

    The pain

    Sending huge, messy web pages to Claude on every step costs up to $0.20 per action, slows down reasoning, and blows through your API budget.

    The Aliax fix

    Aliax strips out tracking scripts, CSS noise, and hidden wrappers before your model sees the page. Your agent gets a crisp 1,500-token view of only the buttons and inputs that matter.

    No token spikes on SPAs
    1.5k clean visual map
    Pillar 03 · The Airbag

    Instant visual replays when agents get stuck

    The pain

    When a cloud agent crashes at Step 12, you're flying blind. You get a generic timeout and have to dig through thousands of lines of terminal logs.

    The Aliax fix

    When an agent gets stuck in a loop, Aliax captures the exact screenshot, the button it tried to click, and the model's thoughts into your dashboard. You see what went wrong in 5 seconds.

    Sentry for agents
    screenshot + DOM + thoughts
    how it works

    Four primitives. Wires into any agent framework in 10 lines.

    npm i aliax · pip install aliax — four primitives compatible with Browser-Use, Stagehand, LangChain, or custom loops. The code below is the whole loop.

    01/04 · parseUi
    1. 01

      parseUiThe Compactor. 100k-token DOM → 1.5k-token semantic map.

      • Numbered-box perception painted by Chromium itself (no Pillow / OpenCV)
      • 1 credit per call — 90% smaller payload than raw HTML, before the VLM is billed
      • render_config: { quality: 40 } shrinks the screenshot ~10×, slashing VLM token cost
    2. 02

      SYSTEM_INSTRUCTIONSVersioned browser-control prompt, pinned to SDK release.

      • Versioned, tested browser-control prompt — exported from aliax
      • When GPT-4V or Claude breaks JSON output, we ship the fix → npm update
      • You never author or maintain a browser-control prompt again — model drift is our problem
    3. 03

      executeThe Steady Hand. CLS-immune execution via data-aliax-id.

      • Five-tier resolver: locator → jsclick → rebind → coords → blocked_disabled
      • Recovers from re-renders & SPA wipes silently
      • Returns {ok, action, execution_tier, coords?, error?} — never raises on browser noise
    4. 04

      reportIssueThe Airbag. Stagnation-proven crash capture.

      • Gatekeeper requires 3 identical DOM-state hashes OR a period-2/3/4 action cycle (scans up to 8 history entries)
      • Rejections come back as {status:'rejected', msg} — no exception, no charge
      • On proof, deploys the Airbag: captures the Set-of-Mark frame, compact DOM map, agent thoughts, and the incorrect action — visual replay in your dashboard
      • 200 credits per accepted capture · auto-refunded on reject
    scroll
    agent-loop.ts
    TypeScript
    while (!done) {
      const ctx = await aliax.parseUi(page);
      const step = await vlm.decide({
        system: SYSTEM_INSTRUCTIONS,
        image: ctx.imageBytes,
        map: ctx.llmTextBlock(),
      });
    
      const result = await aliax.execute(page, step);
    
      // The Airbag: proves stagnation, then ships the visual crash trace to your dashboard
      const issue = await aliax.reportIssue(page, {
        goal: step.goal,
        thoughts: step.thoughts,
        lastAttemptedAction: step.action,
        failureReason: step.failure_reason,
      });
      if (issue.status === "ok") break; // captured — screenshot + DOM + thoughts land in your dashboard with a visual replay
    }
    ExecuteResult = { ok, action, element_id?, coords?, execution_tier: "locator"|"jsclick"|"rebind"|"coords"|"blocked_disabled", error? }
    IssueResult = { status: "ok"|"rejected"|"error", msg?, capture_id? }
    // stagnation is telemetry, not an exception. Neither call ever raises.
    Agent Activep99 parseUi · 87ms
    PROD · us-east-1
    SDK v1 · zero orchestration layer

    Every parse, every execute, every failure — in one command center.

    Watch parse_ui and execute stream in real-time. Credit balance, success rate, peak load — pay-as-you-go, never a surprise bill.

    aliax.xyz/dashboard
    Aliax Execution Console showing parse_ui volume, execute success rate, credit balance, and live SDK telemetry over the last 24 hours.
    parse_ui · streaming
    execute · 83%
    credits · pay-as-you-go
    overdraft capped
    the closed loop — every failure becomes a labeled training row

    Your proprietary VLM dataset, built from your own agent's real-world failures.

    gate
    3× DOM hash match OR period-2/3/4 action cycle
    capture
    Set-of-Mark screenshot + DOM map + agent thoughts
    annotation
    human taps correct element → DPO pair, one row
    export
    JSONL · OpenAI / Anthropic / Together · you own it
    per parse
    0 credit
    per accepted capture
    0 credits
    median · p80 <12h review
    0h
    JSONL export · you own it
    DPO-ready
    stagnation proof · capture/el_41accepted

    goal submit checkout order

    attempt CLICK el_41 (intercepted)

    hash[n-2] 6f3a1c

    hash[n-1] 6f3a1c

    hash[n] 6f3a1c

    3× identical → stagnation

    › charged 200 credits

    › queued · annotator assigned

    › jsonl export ready in ~ 8h

    failure_reason · submit_dead_zone

    works with your existing stack

    Not a replacement. A reliability upgrade.

    Standalone: 3 API calls, own the loop. · Integrated: ~10 lines in your framework's per-step hook. Keep your planner, eliminate flakiness.

    Path A · Standalone

    I'm building a custom agent.

    aliax.parseUi(page) → aliax.execute(page, step)
    • Complete SDK perception loop (parseUi)
    • Full coordinate-free execute() with 18 verbs
    • Standard Python 3.8+ and Node 20+ support
    • Versioned system prompt ships inside the package
    Path B · Integrated

    I already use Browser Use, Stagehand, or LangChain.

    on_step hook · ~10 lines · no planner rewrite
    • Per-step hook — ~10 lines, no planner rewrite
    • No overlapping badges. No dropped shadow DOMs.
    • Works with any browser host (Browserbase, Steel, local)
    • capture_failure() + report_issue() for visual error logs
    vs. the alternatives

    What you get that Browser-Use and Stagehand can't give you.

    Every row is a production failure mode solved out of the box. Drop Aliax into Browser-Use or Stagehand to add durable IDs, visual crash telemetry, and PII redaction.

    capabilityaliaxcustom playwright agentbrowser-use / stagehand (without aliax)
    Durable element IDs that survive SPA re-renders
    Bundled DOM mapper — no CDN fetch at runtime
    Versioned system prompt shipped with the SDK
    Automatic stall detection & visual crash replays
    React-safe input typing (triggers native onChange & state)
    Append-only credit ledger · per-call audit
    PII redaction at capture time (HIPAA/PCI ready)
    Network fallback · overdraft hard-cap · backoff
    Private deployment · BYO worker endpoint
    Python · Node parity

    ← scroll to compare →

    › Not a replacement — a supercharger. Aliax wires into Browser-Use, Stagehand, or your custom Playwright agent in < 10 lines and gives it the production features users ask for on GitHub.

    pricing

    Pay for what runs. Nothing else.

    No seats. No platform fee. No minimums. We only earn when your agent runs — and every label the SDK rejects is auto-refunded.

    the compactorparseUi
    1 creditper parse

    • Zero signup: 500 free parses in your local sandbox
    • Sign up for 1,000 free credits + dashboard
    • No minimums. No contracts. Stop anytime.
    • Overdraft hard-capped per project
    the airbagcaptureFailure
    200 creditsper accepted capture

    • 200 credits per accepted capture
    • Auto-refund on admin reject
    • Visual replay + JSONL export included

    worked example

    500 parses + 3 escalations = $0.50 + $0.60 = $1.10 for a complete agent run that ends with three labeled failure rows in your export feed.

    Volume contract, on-prem deploy, or annotator SLA?talk to enterprise →
    security · compliance

    Built for the security review you haven't sent us yet.

    RLS by default. PII redacted client-side before upload. Cloudflare + Supabase carry SOC 2 Type II today. Aliax-owned Type I targeted Q4 2026.

    Authentication

    Supabase Auth (email + Google OAuth) for accounts. Scoped, revocable API keys for SDKs — stored as SHA-256 hashes, shown once at creation.

    Permissions · least privilege

    Row-Level Security on every table · API keys scoped + revocable · clients cannot self-elevate.

    Data handling

    no model training

    We store account email, hashed keys, ledger entries, capture metadata, and the screenshots your SDK uploads. We do not sell, share, or train on customer data.

    PII redaction · in your runtime

    redactSelectors:[...] / redact_selectors=[...] — blurred client-side before upload. Retention 30d (enterprise: 24h).

    Infrastructure

    soc 2 inherited

    Cloudflare Workers (6 regions) · Supabase Postgres (us-east-1) · R2/S3 blobs with AES-256 at rest · TLS terminated at edge, origin mTLS-locked.

    SOC 2 + ISO 27001 roadmap

    type ii · q3 2027

    Cloudflare + Supabase/AWS carry SOC 2 Type II and ISO 27001 today — inherited evidence available under NDA. Aliax-owned SOC 2 Type I targeted Q4 2026, Type II + ISO 27001 H2 2027.

    compliance roadmap

    last reviewed · jun 2026

    nowlive

    CC6/CC7/CC8 shadow controls

    Access reviews, change-management audit log, vendor list — internal evidence pack on request.

    q4 2026in flight

    SOC 2 Type I

    Auditor selected. Policy pack frozen. 3-month observation window starting Sep 2026.

    q3 2027planned

    SOC 2 Type II

    12-month operating window. Report delivered to enterprise accounts under NDA.

    h2 2027planned

    ISO 27001 + DPA template

    ISMS rolled out alongside Type II. Standard DPA + sub-processor list public.

    Need the inherited Cloudflare + Supabase evidence pack, internal policies, or a pre-filled CAIQ today? We turn it around within 1 business day under NDA.

    faq

    The questions cynical CTOs ask before they ship to production.

    Short answers, no marketing fluff. If something is missing, mail support@aliax.xyz and we'll add it here.

    getting started
    pricing
    reliability
    model drift
    the airbag

    Still need details? support@aliax.xyz · enterprise + procurement enterprise@aliax.xyz

    The missing reliability runtime for Browser-Use, Stagehand, and custom VLM agents.

    Zero ghost clicks · Deterministic element binding · 90% fewer tokens

    Install the SDK and call new Aliax() — no API key, no account. A free keyless sandbox is provisioned automatically with 500 free parses cached in ~/.aliax/credentials. When you're ready for the dashboard and visual crash telemetry, sign up for 1,000 bonus credits.

    $ npm i aliax

    $ pip install aliax

    no key needed · 500 free parses · cached locally · instant start