E2LLM for developers

How your AI actually reads a page, why deterministic perception makes long action chains viable, what breaks and what doesn't, and which clients are tested. Start here, then go deep.

Start here

The depth pages

How your AI sees the page

SiFR is the structured snapshot your AI reads instead of raw HTML or pixels — roles, text, selectors, positions, salience. What it is, and why it's compact.

SiFR format →

Structured browser perception

The problem with screenshots and raw DOM, and what a model-readable representation of rendered page state gives your AI instead.

Read the piece →

Runtime snapshots

The series on capturing what a page actually is at runtime — state, change, and the shape of a snapshot over time.

Runtime snapshots →

Set-up guides

Connect the AI client you already use, per client. Install, sign in, paste the connection, and go.

Docs & setup →

Why determinism matters

Long chains only work if each step is reliable

A task that runs many steps is only as reliable as the product of its per-step reliability. Perception is where most of that reliability is won or lost — a page read the same way every time is a page your AI can act on repeatedly.

If each step succeeds with probability p, an N-step task succeeds with p^N. At p = 0.83 per step, a 20-step task lands around 2.4% of the time. Deterministic perception pushes p toward 1 — which is what makes long chains viable at all.

This is arithmetic, not a benchmark: the point is the shape of the curve, not a measured success rate. Your mileage depends on the task, the site, and the model doing the reasoning.

Client compatibility

What we've tested

E2LLM connects over an open protocol, so compatible clients generally work. These are the ones we test directly.

Client	Status	Notes
Claude	Tested	Desktop and web
Claude Code	Tested	CLI
ChatGPT	Tested	Connectors
Codex	Tested	CLI
Grok	Tested	Connector verified
Perplexity	Tested	Connector verified
Mistral	Connect-only	Connect via its own client; not yet tested end-to-end

Other compatible clients — Cursor, VS Code, Gemini among them — should work, though we haven't tested every one. If a client speaks the protocol, it can connect.

Honest limitations

What breaks, and what doesn't

E2LLM reads standard, rendered DOM. Where a surface departs from that, perception degrades gracefully rather than lying about what it sees.

Standard DOM surfaces work well — semantic HTML, forms, ARIA roles, most component libraries. This is the common case.
Canvas and WebGL are opaque — a page that paints its UI into a canvas exposes no elements to read. E2LLM reports what the DOM has, not pixels it can't parse.
Heavy custom shadow DOM and iframes vary — cross-origin frames and deeply nested custom elements can hide state; E2LLM surfaces what it can reach.
It degrades honestly — when a region isn't legible, the snapshot says so instead of inventing selectors. Your AI acts on what's real, or asks.
A browser is required — E2LLM runs in your own signed-in browser. That's the boundary, and the point: it acts where you're already authenticated.

Evidence

Repeatability, measured

We're assembling run-over-run repeatability data — same task, same site, many runs — so the determinism claim above is something you can check, not just read. This section links to the numbers once they're in.

Coming soon