Skip to main content
/

Stop your VLM from guessing pixels and wasting your money.

At $15 / 1M tokens, a raw 100k-token DOM costs $0.20 per agent step. Aliax compresses it to a 1,500-token semantic map — $0.0015 — before your VLM is billed. Same page. Same agent. 99.25% cheaper per call.

  • 90% fewer VLM tokensraw 100k-token DOM → compact 1.5k semantic JSON
  • CLS-immune executiondata-aliax-id locators ignore ad reflow and layout shift
  • Visual crash telemetryscreenshot + DOM + thoughts on every stall
  • Per-step hook for frameworksBrowser Use, Stagehand, LangChain — keep your planner
  • no credit card · no lock-in · 5-minute install · overdraft hard-capped

    ~/agent
    $
    // the system prompt ships inside the package, pinned to the SDK release
    import { Aliax, SYSTEM_INSTRUCTIONS } from "aliax";
    
    const aliax = new Aliax({ apiKey: process.env.ALIAX_API_KEY });
    const ctx = await aliax.parseUi(page);
    const decision = await askLLM(ctx);   // {action: "CLICK", element_id: "el_41"}
    const result = await aliax.execute(page, decision);
    
    // reportIssue is the Gatekeeper — only escalates on proven stagnation
    if (!result.ok) await aliax.reportIssue(page, { goal, thoughts, lastAttemptedAction: decision });

    1:1 parity between Node & Python SDKs. Versioned system prompt ships inside the package.

    production-grade reliability for vision-language agents

    • <90msp99 parseUi*
    • 90%DOM token compression
    • CLS-immune element ids
    • PII redaction · bundled mapper
    • append-only ledger · per-call receipt
    • open-source SDK· MIT
    • python · node parity

    The Compactor · before / after

    This is what your VLM sees on every step.

    Same page. Same agent. $0.20 vs. $0.0015. The diff is your DOM.

    raw HTML DOM · what other agents send
    ~100,000 tokens
    <div class="tw-flex tw-flex-col tw-min-h-screen tw-bg-gray-50 dark:tw-bg-gray-900" data-reactroot="">
      <div class="tw-fixed tw-inset-x-0 tw-top-0 tw-z-50 tw-bg-white/80 tw-backdrop-blur-md tw-border-b tw-border-gray-200">
        <nav class="tw-mx-auto tw-flex tw-max-w-7xl tw-items-center tw-justify-between tw-px-4 tw-py-3" aria-label="Main">
          <a href="/" class="tw-flex tw-items-center tw-gap-2 tw-text-base tw-font-semibold tw-tracking-tight">
            <svg viewBox="0 0 24 24" class="tw-h-6 tw-w-6 tw-fill-current" aria-hidden="true">
              <path d="M12 2L2 7l10 5 10-5-10-5zM2 17l10 5 10-5M2 12l10 5 10-5"/>
            </svg>
            <span data-testid="brand">Acme Shop</span>
          </a>
          <ul class="tw-hidden md:tw-flex tw-items-center tw-gap-6 tw-text-sm tw-text-gray-600">
            <li><a href="/shop" class="hover:tw-text-gray-900 tw-transition-colors">Shop</a></li>
            <li><a href="/cart" class="hover:tw-text-gray-900 tw-transition-colors" data-cart-count="3">Cart (3)</a></li>
            <li><a href="/account" class="hover:tw-text-gray-900 tw-transition-colors">Account</a></li>
          </ul>
          <button type="button" class="tw-inline-flex tw-items-center tw-rounded-md tw-bg-indigo-600 tw-px-3.5 tw-py-2 tw-text-sm tw-font-semibold tw-text-white tw-shadow-sm hover:tw-bg-indigo-500 focus-visible:tw-outline focus-visible:tw-outline-2 focus-visible:tw-outline-offset-2 focus-visible:tw-outline-indigo-600" data-testid="checkout-cta" onclick="trackClick('checkout-cta')">
            Checkout
          </button>
        </nav>
      </div>
      <script>window.__INITIAL_STATE__ = {"cart":{"items":[...],"total":89.40,"currency":"USD","shippingMethods":[...]},"user":{"id":"u_8421","email":"...
    …~96,000 more tokens of Tailwind, scripts, hydration state → $0.20 per VLM call
    Aliax compact map · what your VLM sees
    ~1,500 tokens
    shop.example.com/cart
    1
    2
    3
    4
    5

    numbered Set-of-Mark overlay · drawn natively by the SDK

    [
      { "id":"el_1", "role":"link",   "label":"Shop",     "bounds":[12,38,60,14] },
      { "id":"el_2", "role":"link",   "label":"Cart (3)", "bounds":[78,38,40,14] },
      { "id":"el_3", "role":"button", "label":"Checkout", "bounds":[..],  "primary":true },
      { "id":"el_4", "role":"input",  "label":"Discount code" },
      { "id":"el_5", "role":"button", "label":"Apply" }
    ]
    Same page, same agent → $0.0015 per VLM call · 99.25% cheaper

    Your DOM is costing you $0.20 per agent step. Measure it on your URL.

    Paste any public URL. A headless Chromium on Cloudflare runs the published Aliax SDK 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

    The three mathematical pillars

    One SDK. Zero ghost clicks. 90% cheaper tokens. Visual crash traces.

    100k → 1.5k tokens$0.0015 / parse<90ms p990 ghost clicks
    Pillar 01 · The Steady Hand

    CLS-immune deterministic execution

    The pain

    Traditional visual agents click static X,Y coordinates. If an ad loads or the layout shifts a single pixel, they click empty space and the run fails.

    The Aliax fix

    Dynamic DNA-stamping: the SDK attaches a temporary, invisible data-aliax-id to every interactable node. Playwright resolves the live element at the millisecond of execution — even after scroll, reflow, or mobile rotation.

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

    90% DOM token savings

    The pain

    Sending a raw 100,000-token HTML DOM to Claude on every step costs up to $0.20 per action and bankrupts your agent loop.

    The Aliax fix

    Aliax recursively walks the page, strips Tailwind utilities, tracking scripts, and redundant styling, and condenses it into a clean ~1.5k-token semantic JSON list before the VLM is ever billed.

    100k → 1.5k tokens
    per parse, average
    Pillar 03 · The Airbag

    Visual crash telemetry

    The pain

    When a cloud agent crashes at Step 12, developers are blind. They get a generic timeout and have to parse thousands of lines of terminal logs.

    The Aliax fix

    reportIssue() packages the exact screenshot, DOM state, the AI's thoughts, and the failure reason into a Sentry-style visual timeline on your dashboard — gated by a stagnation proof so a stuck loop can never burn credits abusively.

    Sentry for agents
    DOM + image + thoughts
    how it works

    Four calls. Production-ready from day one.

    npm i aliax · pip install aliax — four primitives around your existing VLM. 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

    Interoperable infrastructure

    How do you build your agents?

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

    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
    • 90% fewer VLM tokens on every step
    • Works with any browser host (Browserbase, Steel, local)
    • capture_failure() + report_issue() for visual error logs
    vs. the alternatives

    The production reliability layer you'd spend six weeks building — already wired.

    Every row is a sprint you don't have to run. The self-built column assumes production looks like your local dev environment. It never does.

    capabilityaliaxplaywright + gpt-4vbrowser use / stagehand
    Durable element IDs that survive SPA re-renders
    Bundled DOM mapper — no CDN fetch at runtime
    Versioned system prompt shipped with the SDK
    Stagnation-gated human escalation (state-hash proof)
    React-safe TYPE (descriptor bypass + InputEvent)
    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 →

    This is a lightweight SDK — you keep your Playwright setup and your VLM. Aliax is the production reliability layer between your VLM and a real browser. You stay in control of the agent.

    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

    • 1,000 free signup parses
    • 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.

    pricing
    reliability
    model drift
    the airbag

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

    Still paying $0.20 per agent step?
    Your DOM is the problem.

    Every agent step you ship today without Aliax sends a raw 100,000-token DOM to your VLM. At $50K/month, that's ~$45K in recoverable spend. Install is npm i aliax. First 1,000 parses free.

    $ npm i aliax·$ pip install aliax